#include "Stack.h"
#include "Queue.h"
//void Test1()
//{
//	ST s;
//	STInit(&s);
//	STPush(&s, 1);
//	STPush(&s, 2);
//	STPush(&s, 3);
//	STPush(&s, 4);
//	STPush(&s, 5);
//	printf("%d\n", STSize(&s));
//	while (!STEmpty(&s))
//	{
//		printf("%d ", STTop(&s));
//		STPop(&s);
//	}
//	printf("\n");
//
//	STDestroy(&s);
//}

//void Test2()
//{	
//	Queue q;
//	QueueInit(&q);
//	QueuePush(&q, 1);
//	QueuePush(&q, 2);
//	QueuePush(&q, 3);
//	printf("%d ", QueueFront(&q));
//	QueuePop(&q);
//	QueuePush(&q, 4);
//	printf("%d ", QueueFront(&q));
//	QueuePop(&q);
//	QueuePush(&q, 5);
//
//	while (!QueueEmpty(&q))
//	{
//		printf("%d ", QueueFront(&q));
//		QueuePop(&q);
//	}
//
//	QueueDestroy(&q);
//}
//typedef struct {
//    Queue q1;
//    Queue q2;
//} MyStack;
//
//
//MyStack* myStackCreate() {
//    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
//    QueueInit(&pst->q1);
//    QueueInit(&pst->q2);
//    return pst;
//}
//
//void myStackPush(MyStack* obj, int x) {
//    if (!QueueEmpty(&obj->q1))
//    {
//        QueuePush(&obj->q1, x);
//    }
//    else
//    {
//        QueuePush(&obj->q2, x);
//    }
//}
//
//int myStackPop(MyStack* obj) {
//    Queue* empty = &obj->q1;
//    Queue* noempty = &obj->q2;
//    if (!QueueEmpty(&obj->q1))
//    {
//        empty = &obj->q2;
//        noempty = &obj->q1;
//    }
//    while (QueueSize(noempty) > 1)
//    {
//        QueuePush(empty, QueueFront(noempty));
//        QueuePop(noempty);
//    }
//    int top = QueueFront(noempty);
//    QueuePop(noempty);
//    return top;
//}
//
//int myStackTop(MyStack* obj) {
//    if (!QueueEmpty(&obj->q1))
//    {
//        return QueueBack(&obj->q1);
//    }
//    else
//    {
//        return QueueBack(&obj->q2);
//    }
//}
//
//bool myStackEmpty(MyStack* obj) {
//    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
//}
//
//void myStackFree(MyStack* obj) {
//    QueueDestroy(&obj->q1);
//    QueueDestroy(&obj->q2);
//    free(obj);
//    obj = NULL;
//}
//void Test3()
//{
//    MyStack* s= myStackCreate();
//    myStackPush(s, 1);
//    myStackPush(s, 2);
//    int a=myStackTop(s);
//    int b=myStackPop(s);
//    bool c=myStackEmpty(s);
//}

typedef struct {
    ST s1;
    ST s2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* qs = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&qs->s1);
    STInit(&qs->s2);
    return qs;
}

void myQueuePush(MyQueue* obj, int x) {
    if (!STEmpty(&obj->s1))
    {
        STPush(&obj->s1, x);
    }
    else
    {
        STPush(&obj->s2, x);
    }
}

int myQueuePop(MyQueue* obj) {
    ST* empty = &obj->s1;
    ST* noempty = &obj->s2;
    if (!STEmpty(&obj->s1))
    {
        noempty = &obj->s1;
        empty = &obj->s2;
    }
    while (STSize(noempty) > 1)
    {
        STPush(empty, STTop(noempty));
        STPop(noempty);
    }
    int ret = noempty->a[noempty->top-1];
    STPop(noempty);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    ST* empty = &obj->s1;
    ST* noempty = &obj->s2;
    if (!STEmpty(&obj->s1))
    {
        noempty = &obj->s1;
        empty = &obj->s2;
    }
    while (STSize(noempty) > 1)
    {
        STPush(empty, STTop(noempty));
        STPop(noempty);
    }
    int peek = STTop(noempty);
    STPush(empty, STTop(noempty));
    STPop(noempty);
    return peek;
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->s1) && STEmpty(&obj->s2);

}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->s1);
    STDestroy(&obj->s2);
    free(obj);
}
void Test4()
{
    MyQueue* obj = myQueueCreate();
    myQueuePush(obj, 1);
    int p2 = myQueuePop(obj);
    //int p3 = myQueuePeek(obj);
    bool p4 = myQueueEmpty(obj);
    myQueueFree(obj);
}
int main()
{
	//Test1();
	/*Test2();*/
    Test4();
	return 0;
}